<TITLE>GDD Reference Manual</TITLE>
<P><h1>GDD Reference Manual</h1>

<a href="gddref.html#gdd">gdd</a><br>
<a href="gddref2.html#gddAtomic">gddAtomic</a><br>
<a href="gddref2.html#gddScalar">gddScalar</a><br>
<a href="gddref2.html#gddContainer">gddContainer</a><br>
<a href="gddref2.html#gddApplicationTypeTable">gddApplicationTypeTable</a><br>
<P>
<a href="gddref2.html#gddDestructor">gddDestructor</a><br>
<a href="gddref2.html#gddBounds">gddBounds</a><br>
<a href="gddref2.html#gddBoundsxD">gddBounds1D gddBounds2D gddBounds3D</a><br>
<a href="gddref2.html#gddCursor">gddCursor</a><br>
<a href="gddref2.html#gddSemaphore">gddSemaphore</a><br>
<a href="gddref2.html#gddIntLock">gddIntLock</a><br>
<P>
<a href="gddref2.html#aitConvert">aitConvert</a><br>
<a href="gddref2.html#aitTimeStamp">aitTimeStamp</a><br>
<a href="gddref2.html#aitString">aitString</a><br>
<a href="gddref2.html#aitTypes_h">aitTypes/aitEnums</a><br>
<P>
<a href="gddref2.html#gddNewDel_h">new/delete Free List Management</a><br>
<a href="gddref2.html#gddApps_h">Application Type Code Index Labels</a><br>
<a href="gddref2.html#gddErrorCodes_h">gddStatus - Error Codes</a><br>
<P>
<a href="gddref2.html#dbMapper_h">DBR To ait Conversion Functions</a><br>
<a href="gddref2.html#dbMapper_h">gddMakeMapDBR</a><br>
<a href="gddref2.html#dbMapper_h">gddMapDbr</a><br>
<a href="gddref2.html#dbMapper_h">gddAitToDbr</a><br>
<a href="gddref2.html#dbMapper_h">gddDbrToAit</a><br>
<P>
<a href="gdd.html">User's Guide</a><br>

<hr><h2><a name="gddAtomic">gddAtomic</a></h2>
Specialized subclass of gdd that provides conveniences ways to create
and manage array-type GDDs.

<p>#include "gdd.h"<p>

<b><i>gddAtomic(void)</i></b><br>
<b><i>gddAtomic(gddAtomic* dd)</i></b><br>

Construct a new gdd that is empty or that is a copy of another gddAtomic
instance.

<p>
<b><i>gddAtomic(int ApplicationType);</i></b><br>
<b><i>gddAtomic(int ApplicationType, aitEnum PrimitiveType);</i></b><br>
<b><i>gdd(int ApplicationType, aitEnum PrimitiveType, int Dimension,
	aitUint32* ElementCounts);</i></b><br>
<b><i>gddAtomic(int ApplicationType, aitEnum PrimitiveType, int Dimension, ...);
	</i></b><br>

Construct a new gdd, describing various data properties.  If <I>Dimension</I>
is greater that zero, then <I>ElementCounts</I> is an array with Dimension
number of elements in it.  Each element of the array describes how many
elements are in that dimension.  The ElementCount information is used to
initialize the bounds of a GDD.  The last constructor takes a variable
number of arguments which are the upper bounds for each dimension; the
number of variable arguments must be equal to the Dimension argument.

<p>
<b><i>gddStatus getBoundingBoxSize(aitUint32* buf);</i></b><br>
<b><i>gddStatus getBoundingBoxOrigin(aitUint32* buf);</i></b><br>
<b><i>gddStatus setBoundingBoxSize(const aitUint32* const buf);</i></b><br>
<b><i>gddStatus setBoundingBoxOrigin(const aitUint32* const buf);</i></b><br>
Convenience routines for setting bounds information using bounding box
information.  The number of elements of buf must be equal to the dimension
defined in the GDD.  These methods can be used to set the bounds information
within a GDD in a convenience way by specifying the origin and size.
Bounds in GDDs are descibed (origin,element_count) for each dimension.  These
methods provide an alternative method to set all the origins at once or
all the element_counts at once.
<DL>changeType() return codes:
	<DL>
		<DT>0 - Success
		<DT>gddErrorOutOfBounds - If this GDD has dimension zero
	</DL>
</DL>

<hr><h2><a name="gddScalar">gddScalar</a></h2>
Specialized subclass of gddAtomic that provides convenient ways to create
and manage scalar-type GDDs.

<p>#include "gdd.h"<p>

<b><i>gddAtomic(void)</i></b><br>
<b><i>gddAtomic(gddAtomic* dd)</i></b><br>

Construct a new gddScalar that is empty or that is a copy of another gddScalar
instance.

<p>
<b><i>gddAtomic(int ApplicationType);</i></b><br>
<b><i>gddAtomic(int ApplicationType, aitEnum PrimitiveType);</i></b><br>

Construct a new gddScalar, describing various data properties.  Dimension is
a gddScalar is always zero.

<hr><h2><a name="gddContainer">gddContainer</a></h2>
Specialized subclass of gdd that provides convenient ways to create
and manage container-type GDDs.

<p>#include "gdd.h"<p>

<b><i>gddContainer(void)</i></b><br>
<b><i>gddContainer(gddContainer* dd)</i></b><br>

Construct a new gddContainer that is empty or that is a copy of another
gddContainer instance.  A gddContainer always has dimension one and a
single bounds structure allocated to tell how many GDDs are in the container.

<p>
<b><i>gddContainer(int ApplicationType);</i></b><br>
<b><i>gddContainer(int ApplicationType, int total_gdds);</i></b><br>

Construct a new gddContainer, describing the application type.  The argument
total_gdds sets the number GDDs contained within the gddContainer in
the element count of this GDDs bound structure.  The last constructor listed
also creates total_gdds GDDs, puts them together in a linked list and
sets the data field of this GDD to point to the linked list.  The last
constructor creates the container with total_gdds empty GDDs in it.

<p>
<b><i>gddStatus insert(gdd* dd);</i></b><br>
<b><i>gddStatus remove(aitIndex index);</i></b><br>
Insert dd to the container.  Care must be taken not to use the insert method
on a flattened container. Remove GDD number index from the container.  The
GDD at index is removed from the container and unreferenced.
<DL>remove() return codes:
	<DL>
		<DT>0 - Success
		<DT>gddErrorOutOfBounds - If GDD at index does not exist.
	</DL>
</DL>

<p>
<b><i>gdd* operator[](aitIndex index);</i></b><br>
<b><i>gdd* getDD(aitIndex index);</i></b><br>
<b><i>gdd* getDD(aitIndex index, gddScalar*&);</i></b><br>
<b><i>gdd* getDD(aitIndex index, gddAtomic*&);</i></b><br>
<b><i>gdd* getDD(aitIndex index, gddContainer*&);</i></b><br>
Return the GDD at index.

<p>
<b><i>gddCursor getCursor(void) const;</i></b><br>
Get a simple linked list iterator which is useful for manipulating containers.
See gddCursor explanation.

<hr><h2><a name="gddCursor">gddCursor</a></h2>
A simple class for moving forward through the GDDs stored in a container.

<p>#include "gdd.h"<p>

<b><i>gddCursor(const gddContainer* c)</i></b><br>
Construct a new gddCursor that can be used to walk through gddContainer c.

<p><b><i>gddStatus first(.....);</i></b><br>
Set this iterator to the first element of the container.  Returns the
first GDD in the container.

<p><b><i>gddStatus next(.....);</i></b><br>
Set this iterator to the next element of the container.  Returns the
next GDD in the container.

<p><b><i>gddStatus current(.....);</i></b><br>
Returns the current GDD that the cursor points to within the container.

<hr><h2><a name="gddApplicationTypeTable">gddApplicationTypeTable</a></h2>
A database for registering application type names and retrieving application
type codes.  The database also manages GDD prototype structures associated
with application type names.  Methods exist for allocating and freeing GDDs
given a type code.  See User's Guide for details.

<p>#include "gddAppTable.h"<p>

<b><i>gddApplicationTypeTable(aitUint32 total)</i></b><br>
Construct an application type table capable of holding total amount
of application type codes.  The user does not need to create one of these,
the library automatically generates one instance of this class large enough
to hold 512 type codes.  This automatically generated instance registers
all the standard EPICS control system type codes, see User's Guide.

<P><B><I>
gddStatus registerApplicationType(const char* const name, aitUint32& app);<br>
gddStatus registerApplicationTypeWithProto(const char* const name,
	gdd* protoDD, aitUint32& app);<br>
</I></B>
Register an application type <i>name</i>.  The type table will return the
application type code in <i>app</i> that the system has assigned to the name.
The latter function allow a prototype GDD to be registered aloong with
the name.  This prototype is describes the structure of the data associated
with the application type name.  See User's Guide for more details.
<DL>return codes:
	<DL>
		<DT>0 - Success
		<DT>gddErrorAlreadyDefined - If <i>name</i> is already refined, <i>app</i>
		still returns the type code assigned to the name.
		<DT>gddErrorAtLimit - The type table is filled, no more names can be
		stored in it.
	</DL>
</DL>

<P><I><B>
aitUint32 getApplicationType(const char* const name) const;<BR>
char* getName(aitUint32 app) const;<BR>
</B></I>
Convert a character string type name to it's integer value.  Convert an
integer value to it's character string name.

<P><i><b>gddStatus mapAppToIndex(aitUint32 container_app,
		aitUint32 app_to_map, aitUint32& index);</b></i><br>
Special function for converting type codes to container GDD array indexes.
The GDD must be a flattened GDD managed by the application type table for
mapping to take place.  The <i>container_app</i> argument is the main
structure that contains <i>app_to_map</i>.  The <i>index</i> is populated
with the position where <i>app_to_map</i> is within <i>container_app</i>.
See User's Guide for details.
<DL>return codes:
	<DL>
		<DT>0 - Success
		<DT>gddErrorOutOfBounds - app_to_map cannot be mapped
		<DT>gddErrorNotDefined - container_app does not exist or app_to_map not
		in container_app
	</DL>
</DL>

<P><i><b>gddStatus smartCopy(gdd* dest, gdd* src);</b></i><br>
Given any GDD dest and any GDD src, copy all the data from src to dest
where application type codes match.  The src and dest can be any type of
GDD: scalar, array, or container.  The src dset do not need to be the
same type of GDD.  If dest and src are both containers.  The function will
look through each of the src GDDs to find matches for each of the dest GDDs.
SmartCopy() may result in no data being copied if none of the src type codes
match the dest type codes.  The dest and src container GDDs do not need to
be in the same order.
<DL>return codes:
	<DL>
		<DT>0 - Success
		<DT>gddErrorNotAllowed - src or dest is container and is not managed
		<DT>other - see put(const gdd*)
	</DL>
</DL>

<P><i><b>gdd* getDD(aitUint32 app);</b></i><br>
Allocate a GDD for the <i>app</i> and return it.  If app has a prototype
registered with it, then the returned gdd will be managed and match the
prototype.

<P><i><b>gddStatus freeDD(gdd* dd);</b></i><br>
Free any gdd.  The method basically just calls unreference on dd.  If the
GDD is managed, then it puts it onto a free list for it's application type
code.

<P><I><B>
aitUint32 maxAttributes(void) const;<br>
aitUint32 totalregistered(void) const;<br>
</I></B>
Return the total number of names registered in this application type table.
Return the total number of names that can be registered in this application
type table.

<P><i><b>void describe(FILE* fd);</b></i><br>
Print out "#define" statements for each of the names registered in this
table.  Also print out container index labels in the form of #defines.  See
User's Guide for details.  The file gddApps.h is generated using this
function.

<P><i><b>static gddApplicationTypeTable& AppTable(void);</b></i><br>
Return the automatically generated application type table for use in a
program.

<hr><h2><a name="gddDestructor">gddDestructor</a></h2>
The gdd class knows how to run and manage gddDestructors.  User's assign
destructors to gdd by deriving classes from gddDestructor.

<p>#include "gdd.h"<p>

<i><b>
gddDestructor(void);<br>
gddDestructor(void* user_arg);<BR>
</b></i>
Create a gddDestructor,  optionally placing an arbitrary pointer in the
destructor which can be referenced when the destructor is actual run.

<P><i><b>
gddStatus destroy(void* thing_to_remove);<br>
virtual void run(void* thing_to_remove);<BR>
</b></i>
The <i>destroy</i> method in invoked by anyone withing to request the destructor
to be run.  <i>Destroy</i> invokes the user-written function <i>run</i> when
it's reference count goes to zero.  <i>Run</i> should not be invoked
directly by the user.  The argument to <i>destroy</i> is the buffer that
needs to be freed by by the destructor.  The gdd class invokes <i>destroy</i>
when unreference is called and the gdd's reference count goes to zero.  The
default behavior of <i>run</i> is to cast the buffer thing_to_remove to a
character array and delete it.

<P><i><b>
void reference(void);<br>
int refCount(void) const;<BR>
</b></i>
Calling <i>refCount</i> will return the current value in the destructor
reference count.  <i>Reference</i> will bump up the reference count of this
destructor.

<hr><h2><a name="gddBounds">gddBounds</a></h2>
A simple class to describe the boundaries of a dimension.

<p>#include "gdd.h"<p>

<i><b>void setSize(aitIndex c);</b></i><br>
Sets the number of elements for this bounds.

<P><i><b>
void set(aitIndex first, aitIndex cnt);<br>
void get(aitIndex& first, aitIndex& cnt);<BR>
</b></i>
Set and get the first element in this bounds and the number of elements.

<P><i><b>aitIndex size(void) const;</b></i><br>
Return the number of element in this bounds.

<P><i><b>aitIndex first(void) const;</b></i><br>
Return the first element in this bounds.

<hr><h2><a name="gddBoundsxD">gddBounds1D gddBounds2D gddBounds3D</a><br></h2>
Specialized classes for describing with one, two, and three dimension data.
Since three of less dimension are the most common, bounds array classes for
each type exist and are managed on free lists.  All of these classes
overload the new/delete operators so that the memory allocater is not used.
All of these classes are just arrays of gddBounds.  Only one method exists
in these classes, <i>gddBounds* boundArray(void)</i>, which returns a pointer
to the array of gddBounds.

<p>#include "gdd.h"<p>

<hr><h2><a name="gddSemaphore">gddSemaphore</a><br></h2>
Simple wrapper around the underlying OS semphore functions.  Implimentation
is OS dependant and is not really relevant in single threaded application.
This is a binary semaphore meant to be used for locking sections of code
or perhaps in a simple producer/consumer program.

<p>#include "gddUtils.h"<p>

<i><b>
gddSemaphore(void)<br>
gddSemaphore(gddSemType init)<BR>
</b></i>
Create a simple binary gddSemaphore which defaults to full.  Create a
gddSemaphore which is set initially to state <i>init</i>.  <i>Init</i>
is either gddSemEmpty or gddSemFull.

<P><i><b>
void give(void)<br>
void take(void)<BR>
</b></i>
Operations for manipulating the semaphore.  <i>Take</i> will block if the
semaphore is empty, waiting until it is full.  <i>Give</i> sets the
semaphore back to full state.

<P><i><b>int take(aitUint32 usec)</b></i><br>
Attempt to perform the semaphore take operation.  Only block for <i>usec</i>
microseconds.  Returns true if time-out occurred and semaphore is not
really taken.

<hr><h2><a name="gddIntLock">gddIntLock</a><br></h2>
A simple wrapper around OS interrupt locking services.

<p>#include "gddUtils.h"<p>

<hr><h2><a name="aitConvert">aitConvert</a><br></h2>
A set of convenience functions for quickly converting arrays of data from one
aitType to another.  The header file for these functions also contains a
set of standard functions for converting each of the ait types from/to
network byte order.

<p>#include "aitConvert.h"<p>

<P><i><b>void aitConvert(aitEnum desttype, void* dest,
 aitEnum srctype, const void* src, aitIndex count)</b></i><br>
Take <i>count</i> number of elements from <i>src</i> of type <i>srctype</i>,
copy then to <i>dest</i> and at the same time convert them to type
<i>desttype</i>.

<P><i><b>
void aitConvertToNet(aitEnum desttype, void* dest,
 aitEnum srctype, const void* src, aitIndex count)<br>
void aitConvertFromNet(aitEnum desttype, void* dest,
 aitEnum srctype, const void* src, aitIndex count)<BR>
</b></i>
Same as <i>aitConvert</i> but change the byte order or data format to/from
network format.  If the local host data format is network data format,
then these function are exactly the same as aitConvert.

<P><i><b>aitLocalNetworkDataFormatSame</b></i><br>
This is a #define which is true if local host byte order is the same
as network byte order, otherwise it is false.

<hr><h2><a name="aitTimeStamp">aitTimeStamp</a><br></h2>
A class for storing and manipulating standard time stamps.  This time
is similar to POSIX time stamps, it maintains time in seconds/nanoseconds
past a standard epoch.  POSIX defines a time stamp as a long for seconds
and a type time_t for nanoseconds.  Time_t is OS dependant and so is a
long.  aitTimeStamp forces seconds and nanoseconds to be unsigned 32 bit
integers so the storage size is fixed and known.

<p>#include "aitHelpers.h"<P>
Automatically included if aitTypes.h is included.

<P><i><b>
operator double()<br>
operator float()<BR>
</b></i>
Convert (cast) the seconds/nanoseconds to a double or float seconds with
decimal fraction of a second past epoch.

<P><i><b>static aitTimeStamp getCurrent();</b></i><br>
Retrieve the current time in aitTimeStamp format.

<P><i><b>void get(unsigned long &tv_secOut,unsigned long &tv_nsecOut);</b></i><br>
Retreive the various parts of the time stamp as separate quantities.

<P><i><b>aitTimeStamp()</b></i><br>
<i><b>aitTimeStamp(const aitTimeStamp &t)</b></i><br>
<i><b>aitTimeStamp(const unsigned long sec, const unsigned long nsec)</b></i><br>
Create an aitTimeStamp that is initially zero or set to various values.

<P><i><b>
const unsigned NSecPerSec = 1000000000u;<br>
const unsigned NSecPerUSec = 1000u;<br>
const unsigned SecPerMin = 60u;<BR>
</i></b>
Various constants for working with time.

<P><i><b>
aitTimeStamp operator+ (const aitTimeStamp &lhs, const aitTimeStamp &rhs);<br>
aitTimeStamp operator- (const aitTimeStamp &lhs, const aitTimeStamp &rhs);<br>
int operator>= (const aitTimeStamp &lhs, const aitTimeStamp &rhs);<br>
</b></i>
They are global functions for adding and subtracting and comparing time stamps.

<hr><h2><a name="aitString">aitString</a><br></h2>
Standard class for holding and managing a variable length string.  Strings
is GDD have two attributes associated with them: length and state.  Length
is simply the total length of the string and state either constant or
allocated.

<p>#include "aitHelpers.h"<P>
Automatically included if aitTypes.h is included.

<P><i><b>aitString(void);</b></i><br>
Construct an aitString that is empty.

<P><i><b>
aitString(char* str);<BR>
aitString(aitString* str);<BR>
aitString(aitString& str);<BR>
</b></i>
Construct an aitString which contains a <b>copy</b> of <i>str</i>.  The
state of this aitString will be "allocated".

<P><i><b>
aitString(const char* str);<BR>
aitString(const aitString* str);<BR>
aitString(const aitString& str);<BR>
</b></i>
Construct an aitString which contains a <b>reference</b> to <i>str</i>.  The
state of this aitString will be "constant".

<P><i><b>void clear(void);</b></i><br>
Clear out this aitString, freeing up any storage that may be allocated.

<P><i><b>
void dump(void) const;<br>
void dump(const char* id) const;<BR>
</b></i>
Print the contents of this aitString to stdout in a readable format.  Good
tool for debugging or understanding the aitString class.

<P><i><b>
operator const char*(void) const;<BR>
operator char*(void) const;<BR>
</b></i>
Pull out a reference to the string that this aitString is holding.  These
are casting operators from aitString to char*.

<P><i><b>int isConstant(void) const;</b></i><br>
Returns true is this aitString hold a constant string.

<P><i><b>
aitUint32 length(void) const;<BR>
const char* string(void) const;<BR>
</b></i>
Return the length of the string in this aitString.  Return a reference to
the string in this aitString.

<P><i><b>
aitString& operator=(......);<br>
int copy(......);<br>
</b></i>
Create a copy of the variable string arguments in this aitString.  This
aitString attributes will match that of the arguments.   The assignment
operators just invoke copy(......).

<P><i><b>void replaceData(......);</b></i><br>
Replace the data in this aitString with the string in the argument.  This
function will only copy this aitStrings length number of bytes into it's
string from the argument string.

<P><i><b>void installString(......);</b></i><br>
Invoke replaceData if this aitString is "constant".  Invoke copy if this
aitString is not "constant".

<P><i><b>
static aitUint32 totalLength(aitString* array,aitIndex arraySize);<br>
static aitUint32 stringsLength(aitString* array,aitIndex arraySize);<br>
static aitIndex compact(aitString* array, aitIndex arraySize,
		void* buf, aitIndex bufSize);<BR>
</b></i>
totalLength() returns the total number of bytes that an array of aitStrings
requires.  This length include the size of all the strings in the aitStrings.
<i>Array</i> is the aitString array, <i>arraySize</i> is the number of
elements in array <i>array</i>.  The function <i>stringsLength</i>
returns the total length of all the strings in aitString array <i>array</i>.
The function <i>compact</i> takes aitString array <I>array</I> with
<i>arraySize</i> elements and places all the data contiguously into buffer
<i>buf</i>.  The compacted buffer is <i>bufSize</i> number of bytes.  The
<i>compact</i> function places all the aitString instances of the array at
the front of <i>buf</i>.  The aitStrings in buf reference strings that are
further into the buffer <i>buf</i>.  <i>Compact</i> returns the total
number of bytes used in <i>buf</i>.

<hr><h2><a name="aitTypes_h">aitTypes/aitEnums</a><br></h2>
Standard GDD data types and enumerations for them. This header file contains
many macros for dicovering information about aitTypes.  See the header.

<p>#include "aitTypes.h"<p>

<pre>
	aitInt8			8 bit signed integer
	aitUint8			8 bit unsigned integer
	aitInt16			16 bit signed integer
	aitUint16		16 bit unsigned integer
	aitEnum16		16 bit unsigned integer
	aitInt32			32 bit signed integer
	aitUint32		32 bit unsigned integer
	aitFloat32		32 bit floating point number
	aitFloat64		64 bit floating point number
	aitIndex			32 bit unsigned integer for indexing arrays
	aitPointer		largest pointer a system can hold
	aitStatus		32 bit unsigned integer
	aitBool			standard "c" enum - value aitTrue or aitFalse
	aitFixedString	A fixed string of length AIT_FIXED_STRING_SIZE
	aitTimeStamp	The standard seconds/nanoseconds time stamp
	aitString		Class for manipulating and storing strings
</pre>

<P><i><b>
aitTotal<BR>
aitConvertTotal<BR>
aitValid(x)<BR>
aitConvertValid(x)<BR>
</b></i>
Value of the first two are the number of valid types.  All the ait types
cannot be automatically converted using aitConvert.  AitValid(x) returns
true if x has a valid ait type enumeration associated with it.
AitConvertValid(x) returns true if enumerated value x can be converted using
aitConvert.

<P><i><b>aitEnum</i></b><br>
This is an enumerated data type, there is one name per ait types.  See
header file for the definition.

<P><i><b>aitType</i></b><br>
Data union of all the ait types.

<P><i><b>
aitSize[aitTotal]<BR>
aitName[aitTotal]<BR>
aitStringType[aitTotal]<BR>
</b></i>
Arrays used for discovering information about ait types using the enumerated
ait type name as the index into the array.  aitSize returns the size in
bytes of the ait type.  aitName returns a character string name of the
ait type.  aitStringType returns a string which can be used in sscanf to
read or convert a string into the actual ait type.

<hr><h2><a name="gddErrorCodes_h">gddStatus - Error Codes</a><br></h2>
Error codes returned by various GDD library functions and methods.  See header
file.
<P>#include "gddErrorsCodes.h"<P>
<i><b>char* gddErrorMessages[]</b></i><br>
Return an error message string name for an error code.

<hr><h2><a name="gddNewDel_h">new/delete Free List Management</a><br></h2>
<P>#include "gddNewDel.h"<P>
A set of generic member function macros that can be added to any class
to allow the class to be managed on a free list using the new/delete
operators.  See the header file for details on how to use this
facility.  Most GDD library classes use this facility.

<hr><h2><a name="gddApps_h">Application Type Code Index Labels</a><br></h2>
<P>#include "gddApps.h"<P>
This file is generated from the standard application type table.  It
contains all the #define statements for preregistered containers and
application type codes.

<hr><h2>
<a name="dbMapper_h">DBR To ait Conversion Functions</a><br>
<a name="dbMapper_h">gddMapDbr</a><br>
<a name="dbMapper_h">gddAitToDbr</a><br>
<a name="dbMapper_h">gddDbrToAit</a><br>
</h2>
<P>#include "dbMapper.h"<P>
Large set of utility functions for converting between EPICS DBR data types
and GDD containers.

<P><i><b>void gddMakeMapDBR(gddApplicationTypeTable& table);</b></i><br>
The DBR mapping facility is not initialized automatically.  It must be
initialized using this function before any of the functions are called.
It should be passed the standard default
application type table as an argument.

<P><i><b>chtype gddAitToDbr[]</b></i><br>
Given an ait type code, return the equivalent EPICS DBR type code.

<P><i><b>gddDbrToAitTable gddDbrToAit[]</b></i><br>
Given a DBR type code, return a structure that describe the ait/GDD type code
informtion for that DBR type code.  The information in gddDbrToAitTable is
the GDD application type code and GDD application type name for a given DBR
type.  This information is not extremely useful for simple applications.

<P><i><b>gddDbrMapFuncTable gddMapDbr[]</b></i><br>
Array of conversion functions that convert between DBR structures and GDD
types.  The index of this array is always the DBR type code, not the
GDD application type code.   Each element of the array contains to functions:
conv_gdd and conv_dbr.   Conv_gdd takes a DBR structure and returns a GDD
equivalent to the DBR structure.  Conv_dbr takes a GDD and puts all the data
into a DBR structure.

<pre>
struct gddDbrMapFuncTable {
	to_gdd conv_gdd;
	to_dbr conv_dbr;
};

gdd* to_gdd(void* dbr_data_structure, aitIndex dbr_element_count);
int to_dbr(void* dbr_data_structure, gdd* gdd_instance); 
</pre>

<hr>Argonne National Laboratory
<a href="http://www.aps.anl.gov/asd/controls/epics_copyright.html">Copyright</a>
Information<br>
<address>Jim Kowalkowski (jbk@aps.anl.gov)</address> updated 4/12/95

